COMMENT ⊗   VALID 00004 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	\sendnotes{after Indef. Iteration}
C00004 00003	\sample
C00007 00004	\sample
C00010 ENDMK
C⊗;
\sendnotes{after Indef. Iteration}

\exercise
Write a program, using indefinite iterations {\tt (WHILE ... DO)} only, 
that reads a sequence of positive integers terminated by a zero sentinel.
For each number {\tt N}, the program should find the smallest non-negative 
integers $X$ and $Y$ for which $X↑2 - Y↑2 = N$, or announce that there are
no such numbers.  Try the program on

\displayline{21 9 180 4641 32 101 0}

\noindent
Watch out for non-terminating iterations (``infinite loops'').  If you have
trouble, do these problems as warmups:

(1) Read and print the input data, as above, without printing the sentinel.

(2) Read one positive number {\tt N} and find {\tt X, Y} as above.

\noindent
Remember, whenever you write an indefinite iteration, to find a convincing reason
to believe it will terminate.  If it isn't obvious, put it in a comment in the
program.
\endexercise
\sample
\example

\startcode
(****************************************************************)
(*                                                              *)
(*  EXAMPLE OF THE USE OF INDEFINITE ITERATION, AND INPUT FROM  *)
(*    TERMINAL.  THIS PROGRAM COMPUTES A SQUARE ROOT WITHOUT    *)
(*    USING THE STANDARD FUNCTION  `SQRT' .                     *)
(*                                                              *)
(****************************************************************)

PROGRAM DEMOWHILE ;
                                   
VAR     X,                    (* VALUE OF WHICH SQUARE ROOT IS TO
                                 BE TAKEN *)
        ROOT :  REAL ;        (* SQUARE ROOT OF X *)

BEGIN    (* HEADER AND INPUT *)
WRITELN ( TTY, ' THIS PROGRAM COMPUTES SQUARE ROOTS' ) ;
WRITELN ( TTY, ' WITHOUT USING THE BUILT-IN FUNCTION' ) ;
WRITE ( TTY, ' INPUT NUMBER : ' ) ;
BREAK ( TTY ) ;
READ ( TTY, X ) ;

(* INPUT VALIDATION *)
WHILE X < 0.0  DO
    BEGIN
    WRITELN ( TTY, ' NEGATIVE NUMBERS NOT ALLOWED ' ) ;
    WRITE ( TTY, ' TRY AGAIN : ' ) ;
    BREAK ( TTY ) ;
    READ ( TTY, X )
    END ;

(* INITIALIZATION *)
ROOT := 1.0 ;

(* COMPUTATION OF SQUARE ROOT *)
WHILE  ABS( (ROOT - X/ROOT) )  >  1.0E-6   DO
    ROOT := 0.5 * ( ROOT + X/ROOT ) ;

(* OUTPUT *)
WRITE ( TTY, ' SQUARE ROOT OF ', X :8 :4, ' IS ', ROOT :10 :6 )
END.
\endcode

\topoutput
THIS PROGRAM COMPUTES SQUARE ROOTS
WITHOUT USING THE BUILT-IN FUNCTION
INPUT NUMBER : 10.0
SQUARE ROOT OF  10.0000 IS  3.162277

THIS PROGRAM COMPUTES SQUARE ROOTS
WITHOUT USING THE BUILT-IN FUNCTION
INPUT NUMBER : -2.0
NEGATIVE NUMBERS NOT ALLOWED
TRY AGAIN : 2.0
SQUARE ROOT OF  2.0000 IS  1.414213
\botoutput
\sample
\sendnotes{Example re characters}

\example

\startcode
(****************************************************************)
(*                                                              *)
(*  READING IN A NUMBER IN BASE 7 AND CONVERTING IT TO BASE 10  *)
(*                                                              *)
(*  THIS PROGRAM HAS SOME SUBTLE POINTS TO IT:                  *)
(*                                                              *)
(*      1.  THE PARENTHESIS AROUND " ORD(C) - ORD(0) " TO       *)
(*          PREVENT INTEGER OVERFLOW.                           *)
(*                                                              *)
(*      2.  WHEN YOU TRY TO READ A CHARACTER AT THE END OF THE  *)
(*          END OF A LINE, YOU GET A SPACE. THIS IS THE REASON  *)
(*          WHY THE PROGRAM ALWAYS STOPS AT THE END OF A LINE.  *)
(*                                                              *)
(****************************************************************)

PROGRAM CONVERT ( INPUT*, OUTPUT ) ;

VAR     C       :  CHAR ;        (* CHARACTER LAST READ IN.     *)
        VALUE   :  INTEGER ;     (* VALUE IN BASE 10.           *)

BEGIN
C := ' ' ;
WHILE ( C< '0' ) OR ( C> '6' )  DO   READ ( C ) ;
VALUE := ORD ( C ) - ORD ( '0' ) ;
READ ( C ) ;

WHILE ( C >= '0' ) AND ( C <= '6' )  DO
    BEGIN
    VALUE := VALUE*7 + ( ORD (C) - ORD ('0') ) ;
    READ ( C ) 
    END;

WRITELN ( ' DECIMAL VALUE  =  ', VALUE :8 )
END.
\endcode

INPUT:  46

\topoutput
 DECIMAL VALUE       =       34
\botoutput

INPUT:  /////      23       //////

\topoutput
 DECIMAL VALUE       =       17
\botoutput